home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / xdrlib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  12KB  |  363 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Implements (a subset of) Sun XDR -- eXternal Data Representation.
  5.  
  6. See: RFC 1014
  7.  
  8. '''
  9. import struct
  10.  
  11. try:
  12.     from cStringIO import StringIO as _StringIO
  13. except ImportError:
  14.     from StringIO import StringIO as _StringIO
  15.  
  16. __all__ = [
  17.     'Error',
  18.     'Packer',
  19.     'Unpacker',
  20.     'ConversionError']
  21.  
  22. class Error(Exception):
  23.     '''Exception class for this module. Use:
  24.  
  25.     except xdrlib.Error, var:
  26.         # var has the Error instance for the exception
  27.  
  28.     Public ivars:
  29.         msg -- contains the message
  30.  
  31.     '''
  32.     
  33.     def __init__(self, msg):
  34.         self.msg = msg
  35.  
  36.     
  37.     def __repr__(self):
  38.         return repr(self.msg)
  39.  
  40.     
  41.     def __str__(self):
  42.         return str(self.msg)
  43.  
  44.  
  45.  
  46. class ConversionError(Error):
  47.     pass
  48.  
  49.  
  50. class Packer:
  51.     '''Pack various data representations into a buffer.'''
  52.     
  53.     def __init__(self):
  54.         self.reset()
  55.  
  56.     
  57.     def reset(self):
  58.         self._Packer__buf = _StringIO()
  59.  
  60.     
  61.     def get_buffer(self):
  62.         return self._Packer__buf.getvalue()
  63.  
  64.     get_buf = get_buffer
  65.     
  66.     def pack_uint(self, x):
  67.         self._Packer__buf.write(struct.pack('>L', x))
  68.  
  69.     pack_int = pack_uint
  70.     pack_enum = pack_int
  71.     
  72.     def pack_bool(self, x):
  73.         if x:
  74.             self._Packer__buf.write('\x00\x00\x00\x01')
  75.         else:
  76.             self._Packer__buf.write('\x00\x00\x00\x00')
  77.  
  78.     
  79.     def pack_uhyper(self, x):
  80.         self.pack_uint(x >> 32 & 0xFFFFFFFFL)
  81.         self.pack_uint(x & 0xFFFFFFFFL)
  82.  
  83.     pack_hyper = pack_uhyper
  84.     
  85.     def pack_float(self, x):
  86.         
  87.         try:
  88.             self._Packer__buf.write(struct.pack('>f', x))
  89.         except struct.error:
  90.             msg = None
  91.             raise ConversionError, msg
  92.  
  93.  
  94.     
  95.     def pack_double(self, x):
  96.         
  97.         try:
  98.             self._Packer__buf.write(struct.pack('>d', x))
  99.         except struct.error:
  100.             msg = None
  101.             raise ConversionError, msg
  102.  
  103.  
  104.     
  105.     def pack_fstring(self, n, s):
  106.         if n < 0:
  107.             raise ValueError, 'fstring size must be nonnegative'
  108.         
  109.         data = s[:n]
  110.         n = ((n + 3) // 4) * 4
  111.         data = data + (n - len(data)) * '\x00'
  112.         self._Packer__buf.write(data)
  113.  
  114.     pack_fopaque = pack_fstring
  115.     
  116.     def pack_string(self, s):
  117.         n = len(s)
  118.         self.pack_uint(n)
  119.         self.pack_fstring(n, s)
  120.  
  121.     pack_opaque = pack_string
  122.     pack_bytes = pack_string
  123.     
  124.     def pack_list(self, list, pack_item):
  125.         for item in list:
  126.             self.pack_uint(1)
  127.             pack_item(item)
  128.         
  129.         self.pack_uint(0)
  130.  
  131.     
  132.     def pack_farray(self, n, list, pack_item):
  133.         if len(list) != n:
  134.             raise ValueError, 'wrong array size'
  135.         
  136.         for item in list:
  137.             pack_item(item)
  138.         
  139.  
  140.     
  141.     def pack_array(self, list, pack_item):
  142.         n = len(list)
  143.         self.pack_uint(n)
  144.         self.pack_farray(n, list, pack_item)
  145.  
  146.  
  147.  
  148. class Unpacker:
  149.     '''Unpacks various data representations from the given buffer.'''
  150.     
  151.     def __init__(self, data):
  152.         self.reset(data)
  153.  
  154.     
  155.     def reset(self, data):
  156.         self._Unpacker__buf = data
  157.         self._Unpacker__pos = 0
  158.  
  159.     
  160.     def get_position(self):
  161.         return self._Unpacker__pos
  162.  
  163.     
  164.     def set_position(self, position):
  165.         self._Unpacker__pos = position
  166.  
  167.     
  168.     def get_buffer(self):
  169.         return self._Unpacker__buf
  170.  
  171.     
  172.     def done(self):
  173.         if self._Unpacker__pos < len(self._Unpacker__buf):
  174.             raise Error('unextracted data remains')
  175.         
  176.  
  177.     
  178.     def unpack_uint(self):
  179.         i = self._Unpacker__pos
  180.         self._Unpacker__pos = j = i + 4
  181.         data = self._Unpacker__buf[i:j]
  182.         if len(data) < 4:
  183.             raise EOFError
  184.         
  185.         x = struct.unpack('>L', data)[0]
  186.         
  187.         try:
  188.             return int(x)
  189.         except OverflowError:
  190.             return x
  191.  
  192.  
  193.     
  194.     def unpack_int(self):
  195.         i = self._Unpacker__pos
  196.         self._Unpacker__pos = j = i + 4
  197.         data = self._Unpacker__buf[i:j]
  198.         if len(data) < 4:
  199.             raise EOFError
  200.         
  201.         return struct.unpack('>l', data)[0]
  202.  
  203.     unpack_enum = unpack_int
  204.     
  205.     def unpack_bool(self):
  206.         return bool(self.unpack_int())
  207.  
  208.     
  209.     def unpack_uhyper(self):
  210.         hi = self.unpack_uint()
  211.         lo = self.unpack_uint()
  212.         return long(hi) << 32 | lo
  213.  
  214.     
  215.     def unpack_hyper(self):
  216.         x = self.unpack_uhyper()
  217.         if x >= 0x8000000000000000L:
  218.             x = x - 0x10000000000000000L
  219.         
  220.         return x
  221.  
  222.     
  223.     def unpack_float(self):
  224.         i = self._Unpacker__pos
  225.         self._Unpacker__pos = j = i + 4
  226.         data = self._Unpacker__buf[i:j]
  227.         if len(data) < 4:
  228.             raise EOFError
  229.         
  230.         return struct.unpack('>f', data)[0]
  231.  
  232.     
  233.     def unpack_double(self):
  234.         i = self._Unpacker__pos
  235.         self._Unpacker__pos = j = i + 8
  236.         data = self._Unpacker__buf[i:j]
  237.         if len(data) < 8:
  238.             raise EOFError
  239.         
  240.         return struct.unpack('>d', data)[0]
  241.  
  242.     
  243.     def unpack_fstring(self, n):
  244.         if n < 0:
  245.             raise ValueError, 'fstring size must be nonnegative'
  246.         
  247.         i = self._Unpacker__pos
  248.         j = i + ((n + 3) // 4) * 4
  249.         if j > len(self._Unpacker__buf):
  250.             raise EOFError
  251.         
  252.         self._Unpacker__pos = j
  253.         return self._Unpacker__buf[i:i + n]
  254.  
  255.     unpack_fopaque = unpack_fstring
  256.     
  257.     def unpack_string(self):
  258.         n = self.unpack_uint()
  259.         return self.unpack_fstring(n)
  260.  
  261.     unpack_opaque = unpack_string
  262.     unpack_bytes = unpack_string
  263.     
  264.     def unpack_list(self, unpack_item):
  265.         list = []
  266.         while None:
  267.             x = self.unpack_uint()
  268.             if x == 0:
  269.                 break
  270.             
  271.             if x != 1:
  272.                 raise ConversionError, '0 or 1 expected, got %r' % (x,)
  273.             
  274.             item = unpack_item()
  275.             continue
  276.             return list
  277.  
  278.     
  279.     def unpack_farray(self, n, unpack_item):
  280.         list = []
  281.         for i in range(n):
  282.             list.append(unpack_item())
  283.         
  284.         return list
  285.  
  286.     
  287.     def unpack_array(self, unpack_item):
  288.         n = self.unpack_uint()
  289.         return self.unpack_farray(n, unpack_item)
  290.  
  291.  
  292.  
  293. def _test():
  294.     p = Packer()
  295.     packtest = [
  296.         (p.pack_uint, (9,)),
  297.         (p.pack_bool, (True,)),
  298.         (p.pack_bool, (False,)),
  299.         (p.pack_uhyper, (0x2DL,)),
  300.         (p.pack_float, (1.9,)),
  301.         (p.pack_double, (1.9,)),
  302.         (p.pack_string, ('hello world',)),
  303.         (p.pack_list, (range(5), p.pack_uint)),
  304.         (p.pack_array, ([
  305.             'what',
  306.             'is',
  307.             'hapnin',
  308.             'doctor'], p.pack_string))]
  309.     succeedlist = [
  310.         1] * len(packtest)
  311.     count = 0
  312.     for method, args in packtest:
  313.         print 'pack test', count,
  314.         
  315.         try:
  316.             method(*args)
  317.             print 'succeeded'
  318.         except ConversionError:
  319.             var = None
  320.             print 'ConversionError:', var.msg
  321.             succeedlist[count] = 0
  322.  
  323.         count = count + 1
  324.     
  325.     data = p.get_buffer()
  326.     up = Unpacker(data)
  327.     unpacktest = [
  328.         (up.unpack_uint, (), (lambda x: x == 9)),
  329.         (up.unpack_bool, (), (lambda x: x is True)),
  330.         (up.unpack_bool, (), (lambda x: x is False)),
  331.         (up.unpack_uhyper, (), (lambda x: x == 0x2DL)),
  332.         (up.unpack_float, (), (lambda x: None if x < x else x < 1.91)),
  333.         (up.unpack_double, (), (lambda x: None if x < x else x < 1.91)),
  334.         (up.unpack_string, (), (lambda x: x == 'hello world')),
  335.         (up.unpack_list, (up.unpack_uint,), (lambda x: x == range(5))),
  336.         (up.unpack_array, (up.unpack_string,), (lambda x: x == [
  337. 'what',
  338. 'is',
  339. 'hapnin',
  340. 'doctor']))]
  341.     count = 0
  342.     for method, args, pred in unpacktest:
  343.         print 'unpack test', count,
  344.         
  345.         try:
  346.             if succeedlist[count]:
  347.                 x = method(*args)
  348.                 if not pred(x) or 'succeeded':
  349.                     pass
  350.                 print 'failed', ':', x
  351.             else:
  352.                 print 'skipping'
  353.         except ConversionError:
  354.             var = None
  355.             print 'ConversionError:', var.msg
  356.  
  357.         count = count + 1
  358.     
  359.  
  360. if __name__ == '__main__':
  361.     _test()
  362.  
  363.